package reservation;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.jdom.Element;

import serialisation.SerializableText;
import serialisation.SerializableXML;

import data.TypeTransport;
import errors.NegativeValueException;
import errors.StartStopException;

/**
 * Classe transport : modélisation d'un objet Transport bénéficiant des
 * caractéristiques de capacité. Elle est rattachée à l'enum TypeTransport qui
 * regroupe les transports existants.
 * 
 * @author Alexandre Boursier and Mamadou Diallo and Cyril Gorrieri and Emmanuel
 *         Menage
 * @version 2012.01.23
 */

public class Transport implements Serializable, SerializableText, SerializableXML {

    private static final long serialVersionUID = -5629281599245045008L;

    /**
     * static qui permet d'incrementer l'ident transport automatiquement
     */
    protected static int ident = 0;
	
	public static int getIdent() {
		return ident;
	}
	
	public static void setIdent(int i) {
		ident = i;
	}

    /**
     * Type du transport choisi
     */
    private TypeTransport categorie;

    /**
     * Capacité d'accueil du transport
     */
    private int capacite;

    /**
     * Identifiant du transport
     */
    private int identTransport;

    /**
     * Créer un transport selon deux paramètres.
     * 
     * @param chosen
     *            Le type de transport choisi.
     * @param maximum
     *            La capacité du transport.
     * @throws NegativeValueException
     * @throws NullPointerException
     * @throws IOException
     * @throws StartStopException
     * @throws NumberFormatException
     */
    public Transport(TypeTransport chosen, int maximum)
            throws NegativeValueException {
        if (maximum <= 0)
            throw new NegativeValueException(maximum);
        this.categorie = chosen;
        this.capacite = maximum;
        this.identTransport = Transport.ident;
        Transport.ident++;
    }

    /**
     * Constructeur de copie
     * 
     * @param t
     *            Transport à copier
     */
    public Transport(Transport t) {
        this.capacite = t.capacite;
        this.categorie = t.categorie;
        this.identTransport = t.identTransport;
        ident++;
    }

    /**
     * Créer un transport existant dans la base de données (XML)
     * 
     * @param identifiant
     *            L'identifiant du transport cible
     * @param chosen
     *            Le type de transport choisi.
     * @param maximum
     *            La capacité du transport.
     * @throws NegativeValueException
     */
    public Transport(int identifiant, TypeTransport chosen, int maximum)
            throws NegativeValueException {
        if (maximum <= 0)
            throw new NegativeValueException(maximum);
        this.identTransport = identifiant;
        if (Transport.ident <= identifiant)
            Transport.ident = identifiant + 1;
        this.categorie = chosen;
        this.capacite = maximum;
    }

    /**
     * @return le type de transport
     */
    public TypeTransport getCategorie() {
        return categorie;
    }

    /**
     * @param le
     *            type de transport à modifier
     * @throws StartStopException
     * @throws NegativeValueException
     * @throws IOException
     * @throws NullPointerException
     * @throws NumberFormatException
     */
    public void setCategorie(TypeTransport categorie)
            throws NumberFormatException, NullPointerException, IOException,
            NegativeValueException, StartStopException {
        this.categorie = categorie;
    }

    /**
     * @return la capacité du transport
     */
    public int getCapacite() {
        return capacite;
    }

    /**
     * @param la
     *            capacité du transport à modifier
     * @throws StartStopException
     * @throws NegativeValueException
     * @throws IOException
     * @throws NullPointerException
     * @throws NumberFormatException
     */
    public void setCapacite(int capacite) throws NumberFormatException,
    NullPointerException, IOException, NegativeValueException,
    StartStopException {
        if (capacite <= 0)
            throw new NegativeValueException(capacite);
        this.capacite = capacite;
    }

    /**
     * @return the identTransport
     */
    public int getIdentTransport() {
        return identTransport;
    }

    /**
     * toString()
     * 
     * @return string contenant la liste des transports
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Transport n°" + identTransport + "\n");
        sb.append("Type : " + categorie + "\n");
        sb.append("Capacité du transport : " + capacite + " places.\n");
        sb.append("---------------------------------- \n");
        return sb.toString();
    }

    /**
     * Surcharge de la méthode equals qui sera utilisé dans une liste lorsque la
     * methode Liste.contains(Objet) est appellée
     * 
     * @param t
     *            L'objet cible
     * @return true si l'identifiant referant de l'objet est le même, false
     *         sinon
     */
    @Override
    public boolean equals(Object t) {
        Transport tr = (Transport) t;
        if (tr.getIdentTransport() == identTransport)
            return true;
        return false;
    }
    
    /**
     * Ajouter tous les attributs d'un objet dans une liste
     * 
     * @return la liste des attributs d'un objet
     */
    public List<String> parseText() {
        List<String> attributes = new ArrayList<String>();
        attributes.add("TRANSPORT");
        attributes.add(String.valueOf(identTransport));
        attributes.add(categorie.toString());
        attributes.add(String.valueOf(capacite));
        return attributes;
    }

    /**
	 * Ajouter tous les attributs d'un objet dans un element XML.
	 * @return l'element contenant l'objet parser en XML
	 */
	@Override
	public Element parseXML() {
		// Créer l'élément correspondant au transport à insérer
		Element transport = new Element("transport");

		// Créer l'élément correspondant a l'identifiant du transport
		Element idTransportE = new Element("idTransport");
		idTransportE.setText(new Integer(identTransport).toString());

		// Ajouter l'identifiant du transport à l'élément transport
		transport.addContent(idTransportE);

		// Créer l'élément correspondant au type de transport
		Element categorieE = new Element("categorie");
		categorieE.setText(categorie.toString());

		// Ajouter la catégorie à l'élement trajet
		transport.addContent(categorieE);

		// Créer l'élément correspondant a l'identifiant du transport
		Element capaciteE = new Element("capacite");
		capaciteE.setText(new Integer(capacite).toString());

		// Ajouter l'identifiant du transport à l'élément transport
		transport.addContent(capaciteE);
		return transport;
	}
}
